{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hybrid Quantum Neural Networks\n",
    "\n",
    "The example below highlights a hybrid quantum neural network workflow with CUDA-Q and PyTorch where both layers can GPU accelerated to maximise performance."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/hybrid.png\" alt=\"hybrid\" width=\"600\">\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We perform binary classification on the MNIST dataset where data flows through the neural network architecture to the quantum circuit whose output is used to classify hand written digits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install the relevant packages.\n",
    "\n",
    "!pip install matplotlib==3.8.4 torch==2.9.1 torchvision==0.24.1 scikit-learn==1.4.2 -q\n",
    "\n",
    "# Use this line if using GPU, change CUDA version according to your system (e.g. cu126, cu128, or cu130)\n",
    "# !pip install matplotlib==3.8.4 torch==2.9.1+cu126 torchvision==0.24.1+cu126 scikit-learn==1.4.2 -q --extra-index-url https://download.pytorch.org/whl/cu126"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the relevant libraries\n",
    "\n",
    "import cudaq\n",
    "from cudaq import spin\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import torch\n",
    "from torch.autograd import Function\n",
    "from torchvision import datasets, transforms\n",
    "import torch.optim as optim\n",
    "import torch.nn as nn\n",
    "import torchvision\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "torch.manual_seed(22)\n",
    "cudaq.set_random_seed(44)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set CUDAQ and PyTorch to run on either CPU or GPU.\n",
    "\n",
    "device = torch.device('cpu')\n",
    "cudaq.set_target(\"qpp-cpu\")\n",
    "\n",
    "#cudaq.set_target(\"nvidia\")\n",
    "#device = torch.device(\"cuda:0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_data(target_digits, sample_count, test_size):\n",
    "    \"\"\"Load and prepare the MNIST dataset to be used \n",
    "    \n",
    "    Args: \n",
    "        target_digits (list): digits to perform classification of \n",
    "        sample_count (int): total number of images to be used\n",
    "        test_size (float): percentage of sample_count to be used as test set, the remainder is the training set\n",
    "        \n",
    "    Returns: \n",
    "        dataset in train, test format with targets \n",
    "    \n",
    "    \"\"\"\n",
    "\n",
    "    transform = transforms.Compose(\n",
    "        [transforms.ToTensor(),\n",
    "         transforms.Normalize((0.1307), (0.3081))])\n",
    "\n",
    "    dataset = datasets.MNIST(\"./data\",\n",
    "                             train=True,\n",
    "                             download=True,\n",
    "                             transform=transform)\n",
    "\n",
    "    # Filter out the required labels.\n",
    "    idx = (dataset.targets == target_digits[0]) | (dataset.targets\n",
    "                                                   == target_digits[1])\n",
    "    dataset.data = dataset.data[idx]\n",
    "    dataset.targets = dataset.targets[idx]\n",
    "\n",
    "    # Select a subset based on number of datapoints specified by sample_count.\n",
    "    subset_indices = torch.randperm(dataset.data.size(0))[:sample_count]\n",
    "\n",
    "    x = dataset.data[subset_indices].float().unsqueeze(1).to(device)\n",
    "\n",
    "    y = dataset.targets[subset_indices].to(device).float().to(device)\n",
    "\n",
    "    # Relabel the targets as a 0 or a 1.\n",
    "    y = torch.where(y == min(target_digits), 0.0, 1.0)\n",
    "\n",
    "    x_train, x_test, y_train, y_test = train_test_split(x,\n",
    "                                                        y,\n",
    "                                                        test_size=test_size /\n",
    "                                                        100,\n",
    "                                                        shuffle=True,\n",
    "                                                        random_state=42)\n",
    "\n",
    "    return x_train, x_test, y_train, y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Classical parameters.\n",
    "\n",
    "sample_count = 1000  # Total number of images to use.\n",
    "target_digits = [5, 6]  # Hand written digits to classify.\n",
    "test_size = 30  # Percentage of dataset to be used for testing.\n",
    "classification_threshold = 0.5  # Classification boundary used to measure accuracy.\n",
    "epochs = 1000  # Number of epochs to train for.\n",
    "\n",
    "# Quantum parmeters.\n",
    "\n",
    "qubit_count = 1\n",
    "hamiltonian = spin.z(0)  # Measurement operator.\n",
    "shift = torch.tensor(torch.pi / 2)  # Magnitude of parameter shift."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train, x_test, y_train, y_test = prepare_data(target_digits, sample_count,\n",
    "                                                test_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot some images from the training set to visualise.\n",
    "if device != 'cpu':\n",
    "    sample_to_plot = x_train[:10].to(torch.device('cpu'))\n",
    "else:\n",
    "    sample_to_plot = x_train[:10]\n",
    "\n",
    "grid_img = torchvision.utils.make_grid(sample_to_plot,\n",
    "                                       nrow=5,\n",
    "                                       padding=3,\n",
    "                                       normalize=True)\n",
    "plt.imshow(grid_img.permute(1, 2, 0))\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QuantumFunction(Function):\n",
    "    \"\"\"Allows the quantum circuit to input data, output expectation values \n",
    "    and calculate gradients of variational parameters via finite difference\"\"\"\n",
    "\n",
    "    def __init__(self, qubit_count: int, hamiltonian: cudaq.SpinOperator):\n",
    "        \"\"\"Define the quantum circuit in CUDA Quantum\"\"\"\n",
    "\n",
    "        @cudaq.kernel\n",
    "        def kernel(qubit_count: int, thetas: np.ndarray):\n",
    "\n",
    "            qubits = cudaq.qvector(qubit_count)\n",
    "\n",
    "            ry(thetas[0], qubits[0])\n",
    "            rx(thetas[1], qubits[0])\n",
    "\n",
    "        self.kernel = kernel\n",
    "        self.qubit_count = qubit_count\n",
    "        self.hamiltonian = hamiltonian\n",
    "\n",
    "    def run(self, theta_vals: torch.tensor) -> torch.tensor:\n",
    "        \"\"\"Excetute the quantum circuit to output an expectation value\"\"\"\n",
    "\n",
    "        #If running on GPU, thetas is a torch.tensor that will live on GPU memory. The observe function calls a .tolist() method on inputs which moves thetas from GPU to CPU.\n",
    "\n",
    "        qubit_count = [self.qubit_count for _ in range(theta_vals.shape[0])]\n",
    "\n",
    "        results = cudaq.observe(self.kernel, self.hamiltonian, qubit_count,\n",
    "                                theta_vals)\n",
    "\n",
    "        exp_vals = [results[i].expectation() for i in range(len(results))]\n",
    "        exp_vals = torch.Tensor(exp_vals).to(device)\n",
    "\n",
    "        return exp_vals\n",
    "\n",
    "    @staticmethod\n",
    "    def forward(ctx, thetas: torch.tensor, quantum_circuit,\n",
    "                shift) -> torch.tensor:\n",
    "\n",
    "        # Save shift and quantum_circuit in context to use in backward.\n",
    "        ctx.shift = shift\n",
    "        ctx.quantum_circuit = quantum_circuit\n",
    "\n",
    "        # Calculate expectation value.\n",
    "        exp_vals = ctx.quantum_circuit.run(thetas).reshape(-1, 1)\n",
    "\n",
    "        ctx.save_for_backward(thetas, exp_vals)\n",
    "\n",
    "        return exp_vals\n",
    "\n",
    "    @staticmethod\n",
    "    def backward(ctx, grad_output):\n",
    "        \"\"\"Backward pass computation via finite difference\"\"\"\n",
    "\n",
    "        thetas, _ = ctx.saved_tensors\n",
    "\n",
    "        gradients = torch.zeros(thetas.shape, device=device)\n",
    "\n",
    "        for i in range(thetas.shape[1]):\n",
    "\n",
    "            thetas_plus = thetas.clone()\n",
    "            thetas_plus[:, i] += ctx.shift\n",
    "            exp_vals_plus = ctx.quantum_circuit.run(thetas_plus)\n",
    "\n",
    "            thetas_minus = thetas.clone()\n",
    "            thetas_minus[:, i] -= ctx.shift\n",
    "            exp_vals_minus = ctx.quantum_circuit.run(thetas_minus)\n",
    "\n",
    "            gradients[:, i] = (exp_vals_plus - exp_vals_minus) / (2 * ctx.shift)\n",
    "\n",
    "        gradients = torch.mul(grad_output, gradients)\n",
    "\n",
    "        return gradients, None, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QuantumLayer(nn.Module):\n",
    "    \"\"\"Encapsulates a quantum circuit into a quantum layer adhering PyTorch convention\"\"\"\n",
    "\n",
    "    def __init__(self, qubit_count: int, hamiltonian, shift: torch.tensor):\n",
    "        super(QuantumLayer, self).__init__()\n",
    "\n",
    "        self.quantum_circuit = QuantumFunction(qubit_count, hamiltonian)\n",
    "        self.shift = shift\n",
    "\n",
    "    def forward(self, input):\n",
    "\n",
    "        result = QuantumFunction.apply(input, self.quantum_circuit, self.shift)\n",
    "\n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Hybrid_QNN(nn.Module):\n",
    "    \"\"\"Structure of the hybrid neural network with classical fully connected layers and quantum layers\"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        super(Hybrid_QNN, self).__init__()\n",
    "\n",
    "        self.fc1 = nn.Linear(28 * 28, 256)\n",
    "        self.fc2 = nn.Linear(256, 128)\n",
    "        self.dropout = nn.Dropout(0.25)\n",
    "\n",
    "        self.fc3 = nn.Linear(128, 64)\n",
    "        self.fc4 = nn.Linear(64, 32)\n",
    "        self.fc5 = nn.Linear(32, 2)\n",
    "        self.dropout = nn.Dropout(0.25)\n",
    "\n",
    "        # The 2 outputs from PyTorch fc5 layer feed into the 2 variational gates in the quantum circuit.\n",
    "        self.quantum = QuantumLayer(qubit_count, hamiltonian, shift)\n",
    "\n",
    "    def forward(self, x):\n",
    "\n",
    "        x = x.view(-1, 28 * 28)  # Turns images into vectors.\n",
    "\n",
    "        x = torch.relu(self.fc1(x))\n",
    "        x = torch.relu(self.fc2(x))\n",
    "        x = self.dropout(x)\n",
    "\n",
    "        x = torch.relu(self.fc3(x))\n",
    "        x = torch.relu(self.fc4(x))\n",
    "        x = torch.relu(self.fc5(x))\n",
    "        x = self.dropout(x)\n",
    "\n",
    "        # Quantum circuit outputs an expectation value which is fed into the sigmoid activation function to perform classification.\n",
    "        x = torch.sigmoid(self.quantum(x))\n",
    "\n",
    "        return x.view(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def accuracy_score(y, y_hat):\n",
    "    return sum((y == (y_hat >= classification_threshold))) / len(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "hybrid_model = Hybrid_QNN().to(device)\n",
    "\n",
    "optimizer = optim.Adadelta(hybrid_model.parameters(),\n",
    "                           lr=0.001,\n",
    "                           weight_decay=0.8)\n",
    "\n",
    "loss_function = nn.BCELoss().to(device)\n",
    "\n",
    "training_cost = []\n",
    "testing_cost = []\n",
    "training_accuracy = []\n",
    "testing_accuracy = []\n",
    "\n",
    "hybrid_model.train()\n",
    "for epoch in range(epochs):\n",
    "\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    y_hat_train = hybrid_model(x_train).to(device)\n",
    "\n",
    "    train_cost = loss_function(y_hat_train, y_train).to(device)\n",
    "\n",
    "    train_cost.backward()\n",
    "\n",
    "    optimizer.step()\n",
    "\n",
    "    training_accuracy.append(accuracy_score(y_train, y_hat_train))\n",
    "    training_cost.append(train_cost.item())\n",
    "\n",
    "    hybrid_model.eval()\n",
    "    with torch.no_grad():\n",
    "\n",
    "        y_hat_test = hybrid_model(x_test).to(device)\n",
    "\n",
    "        test_cost = loss_function(y_hat_test, y_test).to(device)\n",
    "\n",
    "        testing_accuracy.append(accuracy_score(y_test, y_hat_test))\n",
    "        testing_cost.append(test_cost.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 5))\n",
    "\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(training_cost, label='Train')\n",
    "plt.plot(testing_cost, label='Test')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Cost')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(training_accuracy, label='Train')\n",
    "plt.plot(testing_accuracy, label='Test')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CUDA-Q Version proto-0.8.0 (https://github.com/NVIDIA/cuda-quantum f52f3f8e0830e0c78e05ed8d087ae7faf1e58c9f)\n"
     ]
    }
   ],
   "source": [
    "print(cudaq.__version__)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
